בהצלחה! מבוא לתכנות מערכות

Transcription

1 הפקולטה למדעי המחשב ד"ר רן רובינשטיין, מר עומר סטרולוביץ אלכסנדר ליבוב, ראידה נעאמנה, עידו גונן, אפרת לקר, ברק פת, נועם שגב הטכניון - מכון טכנולוגי לישראל מבוא לתכנות מערכות מבחן מועד א' סמסטר אביב 2012 הוראות כלליות משך המבחן: 180 דקות (שלוש שעות). טופס המבחן מכיל 9 עמודים, כולל עמוד זה. יש לענות על כל השאלות במקום המיועד לכך בטופס. מותר לכתוב גם בעט וגם בעיפרון. מומלץ ביותר ראשית לקרוא כל שאלה עד סופה, ורק אח"כ לענות. מותר השימוש בחומר העזר המסופק ועוד שני דפי A4 (דו צדדיים) יש להקפיד על כתיבה ברורה ומסודרת של התשובות. על התשובות להיות קצרות ומדויקות ככל הניתן. אין לרשום קוד מיותר או עובדות כלליות שאינן קשורות לפתרון. אין צורך לתעד את הקוד בפתרונות. אין צורך להקפיד על code conventions כלשהם בעת כתיבת קוד. מבנה המבחן: שאלה סה"כ ניקוד בהצלחה! 1

2 שאלה 1: (13 נק') בשאלה זו נכתוב מנשק עבור ADT בשם LinkedList (או בקיצור.(LList טיפוס זה דומה לטיפוס הרשימה (List) שפגשתם בתרגיל בית מס' 2, והוא מהווה אוסף סדור של איברים, הממומש בצורת רשימה מקושרת. מימוש זה מאפשר ביצוע פעולות מסוימות ביעילות. בנוסף, בניגוד ל- List, ברצוננו ש- LList יתמוך במספר איטרטורים בו זמנית, ועל כן יוגדר טיפוס נוסף בשם שישמש למטרה זו (בדומה לאוספים שראינו ב-++ C ). (Lit או בקיצור ) LListIterator על מנשק ה- ADT לתמוך בפעולות הבאות: 1. יצירת רשימה חדשה 2. העתקת רשימה קיימת 3. שחרור רשימה 4. קבלת איטרטור לתחילת הרשימה, האיטרטור תומך בפעולות הבאות: a. החזרת האיבר המוצבע ע"י האיטרטור, או החזרת NULL אם האיטרטור אינו מצביע לאיבר חוקי b. קידום האיטרטור להצביע לאיבר הבא c. שחרור האיטרטור 5. הוספת איבר לרשימה בהינתן איטרטור. האיבר יתווסף לפני האיבר המוצבע על ידי האיטרטור 6. חלוקת הרשימה למספר רשימות :(split) פונקציה זו תקבל אוסף סדור של תנאים ( הוא פרמטר של הפונקציה) ותחזיר רשימות חדשות כך שהרשימה ה- תכיל את כל האיברים מהרשימה המקורית שקיימו את תנאי אך לא קיימו אף אחד המתנאים הקודמים. ברשימה המקורית יישארו רק האיברים שלא קיימו אף תנאי. לדוגמה, עבור רשימת מספרים וקריאה לפונקציה כשהתנאי הראשון הוא "גדול מ- 5 " והתנאי השני הוא "גדול מ- 10 ", ייוצרו שתי רשימות חדשות, הראשונה תכיל את כל המספרים בין 5 ל- 9, השניה את כל המספרים מ- 10 ומעלה וברשימה המקורית יישארו רק המספרים שערכם קטן מ- 5. כתבו את קובץ המנשק.llist.h - הערה: במקרה של הגדרת טיפוס עבור קודי שגיאה, רשמו במקום רשימת הערכים האפשריים לשגיאות. #ifndef LLIST_H_ #define LLIST_H_ typedef struct llist* LList; typedef struct llist_iterator* LListIterator; typedef enum {... LListResult; typedef void* (*LListCopyFunction)(void*); typedef void (*LListFreeFunction)(void*); typedef void* LListConditionKey; typedef bool (*LListConditionFunction)(void*, LListConditionKey); LList llistcreate(llistcopyfunction copy, LListFreeFunction delete); LList llistcopy(llist llist); void llistdestroy(llist llist); LListIterator llistgetiterator(llist llist); LListResult llistadd(llist llist, LListIterator iterator, void* element); LListResult llistsplit(llist llist, ListConditionFunction[] conditions, ListConditionKey[] keys, int size, LList** output); void* llistiteratorget(llistiterator); void llistiteratoradvance(llistiterator); void llistiteratordestroy(llistiterator); #endif LLIST_H_ 2

3 typedef struct node *Node; struct node { int n; Node next; ; typedef struct dl_node *DLNode; struct dl_node { int n; DLNode next; DLNode previous; ; שאלה 2: (13 נק') נתון מימוש פשוט של צומת עבור רשימה מקושרת של מספרים שלמים :(int) וכן נתון מימוש של צומת עבור רשימה מקושרת דו-כיוונית של מספרים שלמים :(int) כתבו את הפונקציה filtertodl המקבלת את הצומת הראשון של רשימה מקושרת חד-כיוונית, וכן תנאי כלשהו. הפונקציה מחזירה רשימה מקושרת דו-כיוונית המכילה את כל המספרים שקיימו את התנאי ברשימה הראשונה. במקרה של כשלון יש להחזיר.NULL - אם אף איבר אינו מקיים את התנאי יש להחזיר.NULL - יש לאפשר גמישות מירבית בבחירת התנאי. - שימו לב שהרשימות הן ללא איבר דמה (כלומר רשימה ריקה מיוצגת ע"י.(NULL - לנוחותכם, ניתן להשתמש בפונקצית העזר הבאה שמקבלת מצביע לצומת הראשון ברשימה דו-כיוונית, - והורסת את הרשימה (עבור פרמטר NULL הפונקציה אינה עושה דבר): void destroylist(dlnode first); DLNode filtertodl(node head, bool (*condition)(int, void*), void* key) { if (condition == NULL) { return NULL; DLNode newhead = NULL; DLNode previous = NULL; for (Node ptr = head; ptr!= NULL; ptr = ptr->next) { if (!condition(ptr->n, key)) { continue; DLNode newnode = malloc(sizeof(*newnode)); if (!newnode) { destroylist(newhead); return NULL; newnode->n = ptr->n; newnode->next = NULL; newnode->previous = previous; if (!newhead) { newhead = newnode; if (previous) { previous->next = newnode; previous = newnode; return newhead; 3

4 שאלה 3: (12 נק') א. ברשותנו אתר אינטרנט. השרת המנהל את האתר שומר קובץ יומן (log) אשר לתוכו מודפס רישום על כל בקשה של עמוד מהשרת. כל שורה ביומן מכילה את כתובת ה- IP ממנה התבצעה הבקשה, תאריך (ב- 3 שדות, יום, חודש ושנה), שעה ושם הקובץ. להלן מספר שורות לדוגמה מתוך קובץ כזה: :35 index.html :36 about.html :35 index.html :35 options.html :36 images/title.jpg :36 images/title.jpg :37 index.html כתבו פקודה יחידה ב- bash אשר מדפיסה את n הקבצים הפופולריים ביותר. למשל, בדוגמה הנ"ל הקובץ הפופולרי ביותר הוא index.html מאחר וביקשו אותו 3 פעמים. הקובץ השני הכי פופולרי הוא.images/title.jpg לכן עבור 2=n על הפקודה להדפיס: במקרה ומספר קבצים קיבלו את אותו מספר בקשות, הסדר ביניהם אינו חשוב. index.html images/title.jpg > cut -f4 -d" " log.txt sort uniq -c sort -rn cut -c 9- head -$n הסבר: uniq c מקצה 7 תווים למספר, לאחר מכן רווח ולאחר מכן שם הקובץ. ב. כתבו תסריט בשם make_blah אשר ייצור תיקיה בשם,statistics ובתוך תיקיה זו ייצור קובץ לכל תאריך המופיע ביומן (ששמו כשם התאריך) ובקובץ זה יופיעו מספר הבקשות לכל אחד מהקבצים שהיו להם בקשות ביום זה, כאשר שמות הקבצים ממוינים בסדר יורד לפי מספר הבקשות. לדוגמה, עבור קובץ היומן שבדוגמה, יווצרו ב- statistics שני קבצים. הקובץ הראשון ייקרא stats ויכיל: הקובץ השני ייקרא stats ויכיל: index.html 1 about.html 1 index.html 2 images/title.jpg 2 options.html 1 #!/bin/bash function swap { while read -a line; do echo ${line[1] ${line[0] done if [[! -d statistics ]]; then mkdir statistics; fi dates=`cut -d" " -f2 log.txt sort uniq` for d in $dates; do grep $d log.txt cut -d" " -f4 sort uniq -c sort -rn swap >> statistics/$d.stats done 4

5 שאלה 4: (12 נק') בתרגול הזכרנו את הדגל הפקודה -MM gcc המועברים אליה כך שיוכלו לשמש כשלד ל- makefile. למשל, דוגמה לשימוש ופלט לפקודה יכול להיות: אשר גורמת ל- gcc להדפיס את רשימת התלויות לקבצי הקוד > gcc -MM *.c main.o: main.c set.h student.h parser.h set.o: set.c set.h student.o: student.c student.h parser.o: parser.c parser.h string_utils.h CC = gcc OBJS = a.o b.o c.o EXEC = prog COMP_FLAG = -std=c99 -Wall -Werror להלן דוגמה ל- makefile שמבוסס על השלד הזה: $(EXEC): $(OBJS) $(CC) $(DEBUG_FLAG) $(OBJS) -o $@ main.o: main.c set.h student.h parser.h $(CC) -c $(DEBUG_FLAG) $(COMP_FLAG) $*.c set.o: set.c set.h $(CC) -c $(DEBUG_FLAG) $(COMP_FLAG) $*.c student.o: student.c student.h $(CC) -c $(DEBUG_FLAG) $(COMP_FLAG) $*.c parser.o: parser.c parser.h string_utils.h $(CC) -c $(DEBUG_FLAG) $(COMP_FLAG) $*.c לאחר שינויים בקוד, ייתכנו שינויים ברשימת התלויות של קובץ. למשל, אם נוסיף include ל- string_utils.h אז יש צורך לעדכן את ה- makefile. ברצוננו לכתוב תסריט אשר יבצע את התחזוקה הזו בצורה אוטומטית. כלומר התסריט update_makefile יקבל כארגומנט שם של קובץ makefile ויעדכן את שורות התלויות בו בהתאם ע"י שימוש בפקודה -MM gcc כדי למצוא את התלויות המעודכנות. - הניחו כי התו ":" מופיע רק בשורות של תלויות בקובץ ה- makefile. - אין צורך לעדכן שורות אחרות ב- makefile. בדוגמה הנ"ל השורות שייתכן ויש צורך לעדכן מודגשות. - השינויים לא כוללים הוספה או הורדה של קבצי c. - כתיבה וקריאה בו זמנית של קובץ יכולה לגרום לשגיאות, המנעו ממקרה זה. #!/bin/bash rm f temp_makefile while read line; do if [[ $line!= *\.o*:* ]]; then echo $line >> temp_makefile else file=`echo $line cut -f1 -d":" cut -f1 -d"."` echo `gcc -MM ${file.c` >> temp_makefile fi done < $1 mv temp_makefile $1 IFS= לפני ה while (זה לא בחומר הפתרון מוחק רווחים/טאבים בתחילת שורה. ניתן הנלמד). למנוע זאת ע"י הוספת 5

6 שאלה 5: (24 נק') שימו לב, בשאלה זו שלושה סעיפים. משחק הלוח Bazenga (שהומצא לצורך שאלה זו), הוא משחק לוח לשני משתתפים, כאשר כל משתתף בתורו בוחר רשימה של מהלכים, ואלו מבוצעים על פי סדרם. להלן קוד (חלקי) לביצוע משחק Bazenga בין שני שחקנים אנושיים: void bazenga(string player1, string player2) { Board board(player1, player2); while (!board.isdone()) { string player = board.getcurrentplayer(); cout << player << " enter your moves: "; cout << board << endl; list<move> moves; cin >> moves; board.do(moves); cout << "Winner: " << board.getwinner(); ברצוננו להרחיב את הקוד הנ"ל, כך שניתן יהיה לשחק גם נגד שחקני מחשב. בפרט, ייתכנו סוגים שונים של שחקני מחשב המשתמשים באסטרטגיות שונות. א. השתמשו במנגנון התבניות (templates) של שפת ++C כדי לפתור את הבעיה. כלומר, כתבו גרסה חדשה של הפונקציה bazenga שהיא פונקציית,template המקבלת כפרמטרים שני שחקנים (ייתכן שהם שונים) ונותנת להם לשחק. בכל תור, על אחד השחקנים לקבל את הלוח ולהחזיר את המהלך הבא שלו. הדגימו את השימוש בפונקציה שלכם ע"י מימוש השחקן האנושי, וקריאה לפונקציה החדשה כך שיתבצע משחק בין שני בני אדם (כמו בדוגמה המקורית). הערות:,p player,p2 player2,p1 - לנוחותכם, ניתן לקצר את שמות המשתנים בקוד למעלה player1).(m moves,b board - במקרה של שחקן לא אנושי, אין להדפיס את הלוח או לקבל כל קלט, אלא יש להעביר לו את הלוח, ולהניח שהוא מממש אלגוריתם כלשהו שבוחר את רשימת המהלכים על פי מצב המשחק. - המנשק של המחלקות Board ו- Move קבוע ואינו ניתן לשינוי. עם זאת ניתן להניח של- Board יש פונקציות נוספות שמאפשרות לשחקן לא אנושי לברר את מצבו בהינתן הלוח (אין צורך להשתמש בפונקציות אלה כאן). - ניתן לשנות עת חתימת הפונקציה.bazenga - ניתן להניח כי השחקנים הם בעלי שמות שונים. template<typename P1, typename P2> void bazenga(p1 p1, P2 p2) { Board board(p1.name(), p2.name()); while (!board.isdone()) { string player = board.getcurrentplayer(); board.do(player == p1.name()? p1.play(board) : p2.play(board)); cout << "Winner: " << board.getwinner(); class HumanPlayer { string name_; HumanPlayer(string name) : name_(name) { string name() const { return name_ list<move> play(const Board& board) { cout << name() << " enter your moves: "; cout << board << endl; list<move> moves; cin >> moves; return moves; ; 6

7 השתמשו במנגנון ההורשה של שפת ++C כדי לפתור את הבעיה. כלומר, כתבו גרסה חדשה של bazenga המקבלת שני שחקנים כלשהם ונותנת להם לשחק. כמו בסעיף הקודם, ממשו את השחקן האנושי. הניחו את אותן ההנחות שהנחתם בסעיף א'. void bazenga(player& p1, Player& p2) { Board board(p1.name(), p2.name()); while (!board.isdone()) { string player = board.getcurrentplayer(); Player& current = player == p1.name()? p1 : p2; board.do(current.play(board)); cout << "Winner: " << board.getwinner(); ב. - ג. class Player { string name_; Player(string name) : name_(name) { virtual ~Player() { virtual list<move> play(const Board& b) = 0; string name() const { return name_ ; class HumanPlayer : public Player { list<move> play(const Board& b) override { cout << name() << " enter your moves: "; cout << board << endl; list<move> moves; cin >> moves; return moves; ; ציינו יתרון של הפתרון שלכם בסעיף ב' על הפתרון שכתבם עבור סעיף א'. הסבירו בקצרה (2-3 שורות לכל היותר) מדוע זהו יתרון. היתרון העיקרי בשימוש בהורשה הוא האפשרות לערב סוגים שונים של שחקנים בזמן ריצה. למשל, ניתן להריץ טורניר בין הרבה סוגי שחקנים שמימושם לא ידוע מראש. שימו לב שהיתרון שאין צורך בבדיקה מפורשת האם שחקן הוא אנושי או מחשב הוא לא יתרון של סעיף ב' לעומת סעיף א' מאחר ופתרון כזה קיים בשני הסעיפים. 7

8 שאלה 6: (12 נק') כשלמדתם אודות printf בשפת C, ראיתם שניתן לקבוע את פורמט הצגת המשתנים בעזרת סימנים מוסכמים במחרוזת הפורמט. כך למשל, על מנת להדפיס מספר מסוג double בדיוק של 5 ספרות היינו מוסיפים לסימן %lf את 5. כך שמתקבלת הפקודה: double pi = printf("%.5lf", pi); בשפת ++C, פעולות דומות מתבצעות על ידי לקריאה למתודות של ערוץ הפלט. על מנת להדפיס מספר בדיוק של 5 ספרות למשל, ניתן להשתמש בקוד הבא: double pi = ; cout.precision(5); cout << pi; המתודה precision של,ostream משנה את רמת הדיוק שבה יודפסו מספרי נקודה צפה. לצערנו, שיטה זו לא נוחה. למשל אם נרצה להדפיס כמה מספרים בדיוקים שונים לא ניתן לעשות זאת בשורה אחת: double a = , b = 2.0; cout.precision(5); cout << a << " "; cout.precision(2); cout << b << endl; ברצוננו לאפשר שיטה נוחה יותר לשינוי הדיוק בהדפסה באמצע שורת הדפסה. למשל, נרצה שהשורה הקוד הבא, תהיה שקולה לקוד הקודם: double a = , b = 2.0; cout << precision(5) << a << " " << precision(2) << b << endl; כתבו את הקוד הדרוש כך שדוגמה זו (ושימושים דומים) יתקמפלו ויעבדו כמצופה. class precision { int digits; precision(int digits) : digits(digits) { friend ostream& operator<<(ostream& os, const precision& p) { os.precision(p.digits); return os; ; 8

9 שאלה 7: (14 נק') א. להלן מימוש בשפת ++C של האלגוריתם הגנרי reduce המקבל תחום איברים, תנאי ופעולה. האלגוריתם מפעיל את הפעולה שהתקבלה על כל איבר בתחום המקיים את התנאי. template<typename Iterator, typename Predicate, typename Function> void reduce(iterator start, Iterator end, Predicate p, Function f) { for(; start!= end; ++start) { if (p(*start)) { f(*start); ציינו במפורש את הדרישות על כל אחד מהפרמטרים לתבנית הפונקציה reduce על מנת ששימוש מסוים בתבנית יעבור הידור. עבור Iterator צריך: אופרטור* המחזיר T כלשהו שמתאים ל- Function - גרסת prefix של אופרטור ++ עבור קידום - אופרטור =! עבור השוואות - ו- Predicate עבור Predicate צריך אופרטור הפעלה המקבל T ומחזיר ערך כלשהו שניתן להמיר ל- bool עבור Function צריך אופרטור הפעלה המקבל T כל הטיפוסים צריכים בנאי העתקה והורס (אשר ניתן לגשת אליהם מהפונקציה כמובן). ב. כתבו את הפונקציה,copy_large_abs המקבלת std::vector<int> ומספר x ומחזירה וקטור חדש המכיל את כל המספרים מהוקטור המקורי שערכם המוחלט גדול מ- x. עליכם להשתמש בפונקציה reduce שהוגדרה מקודם. - ממשו את כל הקוד הדרוש על מנת שהפונקציה תתקמפל. class LargerAbsThan { int n; LargerAbsThan(int n) : n(n) { bool operator()(int x) const { return abs(x) > n; ; class Pusher { vector<int>& v; Pusher(vector<int>& v) : v(v) { void operator()(int n) { v.push_back(n); ; vector<int> copy_large_abs(const vector<int>& v, int x) { vector<int> result; reduce(v.begin(), v.end(), LargerAbsThan(x), Pusher(result)); return result; 9